home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d18 / pibcat.arc / PIBCATZ.PAS < prev   
Encoding:
Pascal/Delphi Source File  |  1989-03-31  |  19.3 KB  |  392 lines
  1. (*----------------------------------------------------------------------*)
  2. (*       Display_ZOO_Contents --- Display contents of .ZOO file         *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Display_ZOO_Contents( ZOOFileName : AnyStr );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*    Procedure: Display_ZOO_Contents                                   *)
  10. (*                                                                      *)
  11. (*    Purpose:   Displays contents of a .ZOO file                       *)
  12. (*                                                                      *)
  13. (*    Calling sequence:                                                 *)
  14. (*                                                                      *)
  15. (*       Display_ZOO_Contents( ZOOFileName : AnyStr );                  *)
  16. (*                                                                      *)
  17. (*          ZOOFileName --- name of .ZOO file whose contents            *)
  18. (*                          are to be listed.                           *)
  19. (*                                                                      *)
  20. (*    Calls:                                                            *)
  21. (*                                                                      *)
  22. (*       Aside from internal subroutines, these routines are required:  *)
  23. (*                                                                      *)
  24. (*          Dir_Convert_Date_And_Time                                   *)
  25. (*                            --- convert DOS packed date/time to string*)
  26. (*          Open_File         --- open a file                           *)
  27. (*          Close_File        --- close a file                          *)
  28. (*          Entry_Matches     --- Perform wildcard match                *)
  29. (*          Display_Page_Titles                                         *)
  30. (*                            --- Display titles at top of page         *)
  31. (*          DUPL              --- Duplicate a character into a string   *)
  32. (*                                                                      *)
  33. (*----------------------------------------------------------------------*)
  34.  
  35. (*----------------------------------------------------------------------*)
  36. (*                  Maps of ZOO file headers and entries                *)
  37. (*----------------------------------------------------------------------*)
  38.  
  39. CONST
  40.    PATHSIZE   = 256                  (* Max length of pathname *);
  41.    FNAMESIZE  = 13                   (* Size of DOS filename   *);
  42.    LFNAMESIZE = 256                  (* Size of long filename  *);
  43.    SIZ_TEXT   = 20                   (* Length of header text  *);
  44.    Valid_ZOO  = $FDC4A7DC            (* Valid ZOO tag          *);
  45.    
  46. TYPE                               
  47.    Header_Text_Type = ARRAY[ 1 .. SIZ_TEXT   ] OF CHAR;
  48.    FName_Type       = ARRAY[ 1 .. FNAMESIZE  ] OF CHAR;
  49.    LFname_Type      = ARRAY[ 1 .. LFNAMESIZE ] OF CHAR;
  50.    Path_Type        = ARRAY[ 1 .. PATHSIZE   ] OF CHAR;
  51.  
  52.                                    (* ZOO file header *)
  53.    ZOO_Header_Type =  RECORD
  54.                          Header_Text : Header_Text_Type     (* Character text      *);
  55.                          ZOO_Tag     : LONGINT              (* Identifies archives *);
  56.                          ZOO_Start   : LONGINT              (* Where data starts   *);
  57.                          ZOO_Minus   : LONGINT              (* Consistency check   *);
  58.                          ZOO_Major   : CHAR                 (* Major version #     *);
  59.                          ZOO_Minor   : CHAR                 (* Minor version #     *);
  60.                       END;
  61.                                    (* One entry in ZOO library *)
  62.                                    (* Fixed part of entry      *)
  63.    ZOO_Fixed_Type  =  RECORD
  64.                                    (* Fixed part of entry *)
  65.                                    
  66.                          ZOO_Tag     : LONGINT              (* Tag -- redundancy check *);
  67.                          ZOO_Type    : BYTE                 (* Type of directory entry *);
  68.                          Pack_Method : BYTE                 (* 0 = no packing, 1 = normal LZW *);
  69.                          Next        : LONGINT              (* Pos'n of next directory entry *);
  70.                          Offset      : LONGINT              (* Position of this file *);
  71.                          Date        : WORD                 (* DOS format date *);
  72.                          Time        : WORD                 (* DOS format time *);
  73.                          File_CRC    : WORD                 (* CRC of this file *);
  74.                          Org_Size    : LONGINT              (* Original file size *);
  75.                          Size_Now    : LONGINT              (* Compressed file size *);
  76.                          Major_Ver   : BYTE                 (* Version required to extract ... *);
  77.                          Minor_Ver   : BYTE                 (* this file (minimum)             *);
  78.                          Deleted     : BYTE                 (* Will be 1 if deleted, 0 if not *);
  79.                          Struc       : BYTE                 (* File structure if any *);
  80.                          Comment     : LONGINT              (* Points to comment;  zero if none *);
  81.                          Cmt_Size    : WORD                 (* Length of comment, 0 if none *);
  82.                          FName       : FName_Type           (* Filename *);
  83.  
  84.                          Var_Dir_Len : INTEGER              (* Length of variable part of dir entry *);
  85.                          Time_Zone   : BYTE                 (* Time zone where file was created *);
  86.                          Dir_CRC     : WORD                 (* CRC of directory entry *);
  87.  
  88.                       END;
  89.  
  90.                                    (* Variable part of entry *)
  91.  
  92.    ZOO_Varying_Type = ARRAY[1..4+PATHSIZE+LFNAMESIZE] OF CHAR;
  93.  
  94.                                    (* Varying field definitions follow  *)
  95.                                    (* for descriptive purposes.  Any or *)
  96.                                    (* all of these can be missing,      *)
  97.                                    (* depending upon the setting of     *)
  98.                                    (* Var_Dir_Len above and NamLen and  *)
  99.                                    (* DirLen here.                      *)
  100.  
  101.  VAR
  102.     NamLen      : BYTE             (* Length of long filename  *);
  103.     DirLen      : BYTE             (* Length of directory name *);
  104.     System_ID   : INTEGER          (* Filesystem ID            *);
  105.    
  106. VAR
  107.    ZOOFile       : FILE                 (* ZOO file to be read             *);
  108.    ZOO_Header    : ZOO_Header_Type      (* Header for ZOO file             *);
  109.    ZOO_Entry     : ZOO_Fixed_Type       (* Entry for one file in ZOO file  *);
  110.    ZOO_Varying   : ZOO_Varying_Type     (* Varying part of ZOO entry       *);
  111.    ZOO_Pos       : LONGINT              (* Current byte offset in ZOO file *);
  112.    Bytes_Read    : INTEGER              (* # bytes read from ZOO file      *);
  113.    Ierr          : INTEGER              (* Error flag                      *);
  114.    Long_Name     : AnyStr               (* Long file name                  *);
  115.  
  116. (*----------------------------------------------------------------------*)
  117. (*        Get_ZOO_Header --- Get initial header entry in ZOO file       *)
  118. (*----------------------------------------------------------------------*)
  119.  
  120. FUNCTION Get_ZOO_Header( VAR Error : INTEGER ) : BOOLEAN;
  121.  
  122. (*----------------------------------------------------------------------*)
  123. (*                                                                      *)
  124. (*    Function:  Get_ZOO_Header                                         *)
  125. (*                                                                      *)
  126. (*    Purpose:   Gets initial ZOO header                                *)
  127. (*                                                                      *)
  128. (*    Calling sequence:                                                 *)
  129. (*                                                                      *)
  130. (*       OK := Get_ZOO_Header( VAR Error : INTEGER ) : BOOLEAN;         *)
  131. (*                                                                      *)
  132. (*          ZOOEntry --- Header data for next file in ZOO file          *)
  133. (*          Error    --- Error flag                                     *)
  134. (*          OK       --- TRUE if header successfully found, else FALSE  *)
  135. (*                                                                      *)
  136. (*----------------------------------------------------------------------*)
  137.  
  138. BEGIN (* Get_ZOO_Header *)
  139.                                    (* Assume no error to start *)
  140.    Error := 0;
  141.                                    (* Read in the file header entry. *)
  142.  
  143.    BlockRead( ZOOFile, ZOO_Header, SizeOf( ZOO_Header ), Bytes_Read );
  144.    Error := 0;
  145.                                    (* If we didn't read enough, assume     *)
  146.                                    (* it's not a ZOO file at all.          *)
  147.  
  148.    IF ( Bytes_Read <  SizeOf( ZOO_Header ) ) THEN
  149.       Error := Format_Error
  150.                                    (* Check signature.  If wrong, then    *)
  151.                                    (* file is bad or not an ZOO file at   *)
  152.                                    (* all.                                *)
  153.                                    
  154.    ELSE IF ( ZOO_Header.ZOO_Tag <> Valid_ZOO ) THEN
  155.       Error := Format_Error
  156.    ELSE                            (* Header looks ok -- we got    *)
  157.                                    (* the entry data.  Position to *)
  158.                                    (* first file entry             *)
  159.       WITH ZOO_Entry DO
  160.          ZOO_Pos := ZOO_Header.ZOO_Start;
  161.  
  162.                                     (* Report success/failure to calling *)
  163.                                     (* routine.                          *)
  164.  
  165.    Get_ZOO_Header := ( Error = 0 );
  166.  
  167. END   (* Get_ZOO_Header *);
  168.  
  169. (*----------------------------------------------------------------------*)
  170. (*        Get_Next_ZOO_Entry --- Get next file entry in ZOO file        *)
  171. (*----------------------------------------------------------------------*)
  172.  
  173. FUNCTION Get_Next_ZOO_Entry( VAR ZOO_Entry : ZOO_Fixed_Type;
  174.                              VAR Error     : INTEGER ) : BOOLEAN;
  175.  
  176. (*----------------------------------------------------------------------*)
  177. (*                                                                      *)
  178. (*    Function:  Get_Next_ZOO_Entry                                     *)
  179. (*                                                                      *)
  180. (*    Purpose:   Gets header information for next file in ZOO file      *)
  181. (*                                                                      *)
  182. (*    Calling sequence:                                                 *)
  183. (*                                                                      *)
  184. (*       OK := Get_Next_ZOO_Entry( VAR ZOO_Entry : ZOO_Fixed_Type;      *)
  185. (*                                 VAR Error     : INTEGER );           *)
  186. (*                                                                      *)
  187. (*          ZOO_Entry --- Header data for next file in ZOO file         *)
  188. (*          Error     --- Error flag                                    *)
  189. (*          OK        --- TRUE if header successfully found, else FALSE *)
  190. (*                                                                      *)
  191. (*----------------------------------------------------------------------*)
  192.  
  193. BEGIN (* Get_Next_ZOO_Entry *)
  194.                                    (* Assume no error to start *)
  195.    Error := 0;
  196.                                    (* Position to file entry   *)
  197.    Seek( ZOOFile, ZOO_Pos );
  198.                                    (* Read in the file header entry. *)
  199.  
  200.    BlockRead( ZOOFile, ZOO_Entry, SizeOf( ZOO_Entry ), Bytes_Read );
  201.    Error := 0;
  202.                                    (* If we didn't read enough, assume  *)
  203.                                    (* an error.                         *)
  204.  
  205.    IF ( Bytes_Read <  SizeOf( ZOO_Entry ) ) THEN
  206.       Error := Format_Error
  207.                                    (* Check signature.  If wrong, then    *)
  208.                                    (* file is bad or not an ZOO file at   *)
  209.                                    (* all.                                *)
  210.                                    
  211.    ELSE IF ( ZOO_Entry.ZOO_Tag <> Valid_ZOO ) THEN
  212.       Error := Format_Error
  213.    ELSE                            (* Header looks ok -- we got    *)
  214.                                    (* the entry data.  Position to *)
  215.                                    (* next header.                 *)
  216.       BEGIN
  217.          ZOO_Pos := ZOO_Entry.Next;
  218.          IF ( ZOO_Pos = 0 ) THEN
  219.             Error := End_Of_File;
  220.       END;   
  221.                                     (* Report success/failure to calling *)
  222.                                     (* routine.                          *)
  223.  
  224.    Get_Next_ZOO_Entry := ( Error = 0 );
  225.  
  226. END   (* Get_Next_ZOO_Entry *);
  227.  
  228. (*----------------------------------------------------------------------*)
  229. (*         Display_ZOO_Entry --- Display ZOO entry                      *)
  230. (*----------------------------------------------------------------------*)
  231.  
  232. PROCEDURE Display_ZOO_Entry( ZOO_Entry : ZOO_Fixed_Type );
  233.  
  234. VAR
  235.    FileName   : AnyStr;
  236.    DirectName : AnyStr;
  237.    TimeDate   : LONGINT;
  238.    TimeDateW  : ARRAY[1..2] OF WORD ABSOLUTE TimeDate;
  239.    DelFile    : BOOLEAN;
  240.    
  241. BEGIN (* Display_ZOO_Entry *)
  242.  
  243.    WITH ZOO_Entry DO
  244.       BEGIN
  245.                                    (* Pick up file name *)
  246.  
  247.          FileName := COPY( FName, 1, PRED( POS( #0 , FName ) ) );
  248.  
  249.                                    (* See if this file matches the   *)
  250.                                    (* entry spec wildcard.  Exit if  *)
  251.                                    (* not.                           *)
  252.          IF Use_Entry_Spec THEN
  253.             IF ( NOT Entry_Matches( FileName ) ) THEN
  254.                EXIT;
  255.                                    (* Get date and time of creation *)
  256.          TimeDateW[1] := Time;
  257.          TimeDateW[2] := Date;
  258.  
  259.                                    (* Note if deleted entry *)
  260.  
  261.          DelFile := ( Deleted = 1 );
  262.  
  263.                                    (* Pick up long file name. *)
  264.          Long_Name := '';
  265.  
  266.          IF ( DelFile ) THEN
  267.             Long_Name := '  (Deleted)'
  268.          ELSE
  269.                                    (* Display long file name if requested *)
  270.  
  271.             IF ( Show_Long_File_Names AND ( Var_Dir_Len > 0 ) ) THEN
  272.                BEGIN
  273.                                    (* Read varying part *)
  274.  
  275.                   BlockRead( ZOOFile, ZOO_Varying, Var_Dir_Len, Bytes_Read );
  276.  
  277.                   IF ( Bytes_Read = Var_Dir_Len ) THEN
  278.                      BEGIN
  279.                                    (* Watch out -- assumes string[0] *)
  280.                                    (* contains length of string.     *)
  281.  
  282.                                    (* Get directory size and long file *)
  283.                                    (* name size.                       *)
  284.  
  285.                         NamLen := ORD( ZOO_Varying[ 1 ] );
  286.                         DirLen := ORD( ZOO_Varying[ 2 ] );
  287.  
  288.                                    (* Pick up system ID if we have one.   *)
  289.                                    (* Note MOVE used to extract data from *)
  290.                                    (* varying part of record here too.    *)
  291.  
  292.                         IF ( ( NamLen + DirLen + 2 ) < Var_Dir_Len ) THEN
  293.                            MOVE( ZOO_Varying[ NamLen + DirLen + 3 ], System_ID, 2 )
  294.                         ELSE
  295.                            System_ID := 4095;
  296.  
  297.                                    (* Skip this stuff if we have neither. *)
  298.  
  299.                         IF ( ( DirLen > 0 ) OR ( NamLen > 0 ) ) THEN
  300.                            BEGIN
  301.  
  302.                                    (* Get long name.  If none, just   *)
  303.                                    (* use short name again.  Note --  *)
  304.                                    (* we get 1 less than specified    *)
  305.                                    (* length, since directory and     *)
  306.                                    (* names are stored with trailing  *)
  307.                                    (* #0 = ascii Z string format.     *)
  308.  
  309.                               IF ( NamLen > 0 ) THEN
  310.                                  BEGIN
  311.                                     MOVE( ZOO_Varying[ 3 ] , FileName[ 1 ] , PRED( NamLen ) );
  312.                                     FileName[ 0 ] := CHR( PRED( NamLen ) );
  313.                                  END
  314.                               ELSE
  315.                                  FileName := COPY( FName, 1, PRED( POS( #0 , FName ) ) );
  316.  
  317.                                    (* Get directory name *)
  318.  
  319.                               IF ( DirLen > 0 ) THEN
  320.                                  BEGIN
  321.  
  322.                                     MOVE( ZOO_Varying[ 3 + NamLen ] , DirectName[ 1 ] , PRED( DirLen ) );
  323.                                     DirectName[ 0 ] := CHR( PRED( DirLen ) );
  324.  
  325.                                    (* Append trailing '/' if missing and *)
  326.                                    (* system ID indicates we should      *)
  327.  
  328.                                     IF ( System_ID <= 2 ) THEN
  329.                                        IF ( DirectName[ LENGTH( DirectName ) ] <> '/' ) THEN
  330.                                           DirectName := DirectName + '/';
  331.  
  332.                                  END
  333.                               ELSE
  334.                                  DirectName := '';
  335.  
  336.                                    (* Write directory and file name *)
  337.  
  338.                               Long_Name := DirectName + FileName;
  339.  
  340.                            END;
  341.  
  342.                      END;
  343.  
  344.                   END;
  345.                                    (* Display info for this entry *)
  346.  
  347.          Display_One_Entry( FileName, Org_Size, TimeDate, ZOOFileName,
  348.                             Current_Subdirectory, Long_Name );
  349.  
  350.                                    (* Decrement file count, total bytes *)
  351.                                    (* if file a deleted entry.          *)
  352.          IF ( NOT DelFile ) THEN
  353.             BEGIN
  354.                                    (* Increment total space used  *)
  355.  
  356.                Total_ESpace := Total_ESpace + Org_Size;
  357.  
  358.                                    (* Increment total entry count *)
  359.  
  360.                INC( Total_Entries );
  361.  
  362.             END;
  363.  
  364.       END;
  365.  
  366. END (* Display_ZOO_Entry *);
  367.  
  368. (*----------------------------------------------------------------------*)
  369.  
  370. BEGIN (* Display_ZOO_Contents *)
  371.  
  372.                                    (* Open library file and initialize *)
  373.                                    (* contents display.                *)
  374.  
  375.    IF Start_Contents_Listing( ' ZOO file: ',
  376.                               Current_Subdirectory + ZOOFileName, ZOOFile,
  377.                               ZOO_Pos, Ierr ) THEN
  378.       BEGIN
  379.                                    (* Loop over entries in ZOO file *)
  380.  
  381.          IF Get_ZOO_Header( Ierr ) THEN
  382.             WHILE( Get_Next_ZOO_Entry( ZOO_Entry , Ierr ) ) DO
  383.                Display_ZOO_Entry( ZOO_Entry );
  384.  
  385.                                    (* Close ZOO file *)
  386.  
  387.          End_Contents_Listing( ZOOFile , Ierr );
  388.  
  389.       END;
  390.  
  391. END   (* Display_ZOO_Contents *);
  392.